import { T_srv, Tsrv, ifs, ts, vue } from '@/services';
import { N_oFlowchart, N_oSimpleToolbar } from '@/types';
import customGraphReg from './customGraphReg';
import openDebug from './debug/index.vue';
import {
  I_nodeAttrData,
  I_ruleAttrData,
  I_ruleEditor,
  T_ruleEditor
} from './editor';
import nodeAttr from './nodeAttribute/index.vue';
import resources from './resources/index.vue';
import ruleAttr from './ruleAttribute/index.vue';

// const ID: string = Tsrv.utils.getGUID();
const cf = {
  spliteProportion: 0.55
};
function Text(Target) {
  Target.isOK = true;
}

const edgeEndlessLoopCheck = (
  edges: any,
  beginNodeId: string, // 起始节点ID
  targetNodeId: string // 当前目标节点ID
): boolean => {
  const nextEdges = edges.filter(
    ele => ele.getModel().sourceId === targetNodeId
  );
  if (
    nextEdges.filter(item => item.getModel().targetId === beginNodeId).length >
    0
  ) {
    return true;
  }
  for (const element of nextEdges) {
    if (edgeEndlessLoopCheck(edges, beginNodeId, element.getModel().targetId)) {
      return true;
    }
  }
  return false;
};

// 注册画布新增 删除 连线 ...处理前方法
// key add delelet.. datas 当前操作对象 增加节点时 datas 就是node对象...
const beforeHandleNodeAndEdge = (obj: {
  key: string;
  datas: any;
  graph: any;
}): Promise<boolean> => {
  return new Promise(resolv => {
    const graph = obj.graph;
    const datas = obj.datas;
    const key = obj.key;
    const L_edgesNew = datas.filter(ele => ele.type === 'edge');
    const L_nodesNew = datas.filter(ele => ele.type === 'node');

    // 两节点间只能有一条连线并不能形成闭环;
    if (key === 'add' && datas.length > 0) {
      // 连线规则检查
      for (const element of L_edgesNew) {
        // 自己不能连接自己
        if (element.sourceId === element.targetId) {
          resolv(true);
        }
        // 开始节点直接连接结束结点
        if (
          element.source.getModel().type === `beginNode` &&
          element.target.getModel().type === `endNode`
        ) {
          resolv(true);
        }

        // // 当节点出口必须连接表达式接点
        // if (startAnchorPointName==='caseOut' && element.endAnchorPointName !== `exprIn`) {
        //   return true;
        // }
        const L_sourceNodeType = graph.findById(element.sourceId).getModel()
          .type;
        const L_edgesOld = graph.findAll('edge', edge => {
          const L_model = edge.getModel();

          // 重复连线
          if (
            L_model.sourceId === element.sourceId &&
            L_model.targetId === element.targetId
          ) {
            resolv(true);
          }
          // 两节点闭环
          if (
            edgeEndlessLoopCheck(
              graph.getEdges(),
              element.sourceId,
              element.targetId
            )
          ) {
            resolv(true);
          }
          // [当]节点除外,其它节点不允许出口有多条连线
          if (L_sourceNodeType !== 'caseNode') {
            if (
              L_model.sourceId === element.sourceId &&
              L_model.startAnchorPointName === element.startAnchorPointName
            ) {
              resolv(true);
            }
          }
          resolv(false);
        });
        if (L_edgesOld.length > 0) {
          resolv(true);
        }
      }
      // 节点规则检查

      // 不允许有两个开始节点

      const L_beginNodes = L_nodesNew.filter(n => n.shape === 'beginNode');
      const L_nodesOld = graph.findAll('node', node => {
        return node.getModel().type === 'beginNode';
      });
      if (L_nodesOld.length > 0 && L_beginNodes.length > 0) {
        resolv(true);
      }
    }
    resolv(false);
  });
};

// 画布toolbar
const graphToolbarList = (): Array<N_oSimpleToolbar.I_Conf> => {
  return [
    {
      key: 'wyRuleComp',
      type: 'button',
      class: 'wy-comp',
      title: '编译',
      // 按下的样式 单锁开关按扭样式控制
      isOpen: false,
      disabled: true,
      separator: false
    },
    {
      key: 'wyRuleDebug',
      type: 'button',
      class: 'wy-debug',
      title: '调试',
      // 按下的样式 单锁开关按扭样式控制
      isOpen: false,
      disabled: true,
      separator: false
    },
    {
      key: 'wyRuleIn',
      type: 'button',
      class: 'wy-rule-in',
      title: '加入运行库',
      // 按下的样式 单锁开关按扭样式控制
      isOpen: false,
      disabled: true,
      separator: false
    },
    {
      key: 'wyRuleOut',
      type: 'button',
      class: 'wy-rule-out',
      title: '退出运行库',
      // 按下的样式 单锁开关按扭样式控制
      isOpen: false,
      disabled: true,
      separator: true
    }
  ];
};

// 画布ITEM
const itemList = (): Array<N_oFlowchart.I_item> => {
  return [
    {
      codeNo: 'begin',
      name: '开始',
      label: '开始',
      size: '80',
      type: 'node',
      shape: 'beginNode',
      // 设置用于填充绘画的颜色
      fill: '#b7e0cc',
      // 设置用于笔触的颜色(RGB 或 16 进制)
      stroke: '#6ab7ff',
      // 字体颜色
      labelFill: '#565758',
      // label字体大小
      labelFontSize: 25,
      // 元素列表图标
      color: '',
      image: 'wy-rule-begin-end',
      // 默认不可见
      disabled: true
    },
    {
      codeNo: 'end',
      name: '结束',
      label: '结束',
      size: '80',
      type: 'node',
      shape: 'endNode',
      // 设置用于填充绘画的颜色
      fill: '#78839d',
      // 设置用于笔触的颜色(RGB 或 16 进制)
      stroke: '#6ab7ff',
      // 字体颜色
      labelFill: '#ede614',
      // label字体大小
      labelFontSize: 25,
      color: '#1890ff',
      image: 'wy-rule-begin-end',
      disabled: true
    },
    {
      codeNo: 'if',
      name: '如果',
      label: '如果',
      type: 'node',
      size: '150*75',
      shape: 'ifNode',
      // 设置用于填充绘画的颜色
      fill: '#ede3d5',
      // 设置用于笔触的颜色(RGB 或 16 进制)
      stroke: '#6ab7ff',
      // 字体颜色
      labelFill: '#565758',
      // label字体大小
      labelFontSize: 25,
      color: '#1890ff',
      image: 'wy-rule-if',
      disabled: true
    },

    {
      codeNo: 'switch',
      name: '当',
      label: '当',
      type: 'node',
      size: '150*62',
      shape: 'caseNode',
      // 设置用于填充绘画的颜色
      fill: '#e9d5ed',
      // 设置用于笔触的颜色(RGB 或 16 进制)
      stroke: '#6ab7ff',
      // 字体颜色
      labelFill: '#565758',
      // label字体大小
      labelFontSize: 25,
      color: '#1890ff',
      image: 'wy-rule-switch',
      disabled: true
    },

    {
      codeNo: 'expr',
      name: '表达式',
      label: '表达式',
      type: 'node',
      size: '150*75',
      shape: 'exprNode',
      // 设置用于填充绘画的颜色
      fill: '#d6eaeb',
      // 设置用于笔触的颜色(RGB 或 16 进制)
      stroke: '#6ab7ff',
      // 字体颜色
      labelFill: '#565758',
      // label字体大小
      labelFontSize: 25,
      color: '#1890ff',
      image: 'wy-rule-expr',
      disabled: true
    }
  ];
};

const gridConf = (): any => {
  return {
    tableName: '_sys_rule_lib',
    autoLoad: false,
    columns: [
      {
        field: 'id',
        title: 'ID',
        sortable: true // 是否允许排序
      },
      {
        field: 'ruleNum',
        title: '规则编号',
        width: '100px',
        sortable: true // 是否允许排序
      },
      {
        field: 'ruleName',
        title: '规则名称',
        width: '100px',
        sortable: true // 是否允许排序
      },
      {
        field: 'version',
        title: '版本',
        width: '50px',
        sortable: true // 是否允许排序
      },
      {
        field: 'explain',
        title: '说明',
        width: '100px',
        sortable: true // 是否允许排序
      },
      {
        field: 'trigger',
        title: '触发运算',
        sortable: true // 是否允许排序
      }
    ]
  };
};
export {
  I_nodeAttrData,
  I_ruleAttrData,
  I_ruleEditor,
  N_oFlowchart,
  T_ruleEditor,
  T_srv,
  Tsrv,
  beforeHandleNodeAndEdge,
  cf,
  customGraphReg,
  graphToolbarList,
  gridConf,
  ifs,
  itemList,
  nodeAttr,
  openDebug,
  resources,
  ruleAttr,
  ts,
  vue
};
